package com.lanou.lenanapp.db;

import com.lanou.lenanapp.base.BaseApplication;
import com.lanou.lenanapp.entity.greendao.CollectEntity;
import com.lanou.lenanapp.entity.greendao.CollectEntityDao;
import com.lanou.lenanapp.entity.greendao.CollectImageEntity;
import com.lanou.lenanapp.entity.greendao.DaoSession;
import com.lanou.lenanapp.entity.greendao.ImageEntity;
import com.lanou.lenanapp.entity.greendao.ImageEntityDao;
import com.lanou.lenanapp.entity.greendao.IsChangeIntent;
import com.lanou.lenanapp.entity.greendao.JokeEntity;
import com.lanou.lenanapp.entity.greendao.JokeEntityDao;
import com.lanou.lenanapp.entity.greendao.LoginEntity;
import com.lanou.lenanapp.entity.greendao.LoginEntityDao;
import com.lanou.lenanapp.entity.greendao.LoginOneEntity;
import com.lanou.lenanapp.entity.greendao.SpecialEntity;
import com.lanou.lenanapp.entity.greendao.SpecialEntityDao;

import java.util.List;

import de.greenrobot.dao.query.QueryBuilder;

/**
 * Created by dllo on 16/1/18.
 */
public class DatabaseHelper {
    private static DatabaseHelper helper;//帮助类
    private static DaoSession daoSession;// 会话

    public DatabaseHelper() {
    }
    /**
     * 单例模式 本程序只有一个对象
     * 通过静态方法直接获取给实例对象
     */
    public static DatabaseHelper getHelper(){
        if (helper == null) {
            helper = new DatabaseHelper();
            daoSession = BaseApplication.getDaoSession();
        }
        return helper;
    }
    /**
     * 段子的数据库各种操作
     */
    //添加：段子往数据库中添加集合对象
    public void saveJokeList(List<JokeEntity> jokeEntities){
        daoSession.getJokeEntityDao().insertInTx(jokeEntities);
    }
    public void saveJokeList(JokeEntity jokeEntities){
        daoSession.getJokeEntityDao().insertOrReplace(jokeEntities);
    }
    //查询：查询数据库中 jokeentity 表中所有数据
    public List<JokeEntity> queryAllJoke(){
        return daoSession.getJokeEntityDao().loadAll();
    }
    //段子按 id 查询
    public List<JokeEntity> queryByIdJoke(String wid){
        QueryBuilder<JokeEntity> db = daoSession.getJokeEntityDao().queryBuilder();
        db.where(JokeEntityDao.Properties.Wid.eq("wid"));
        return db.list();
    }
    //更新某个对象
    public  void updataJokeEntity(JokeEntity jokeEntity){
        daoSession.getJokeEntityDao().update(jokeEntity);
    }
    //删除数据库所有
    public void deleteAllJoke(){
        daoSession.getJokeEntityDao().deleteAll();
    }

    /**
     * 趣图的各种方法
     * **/
    public void saveImageList(List<ImageEntity> imageEntities){
        daoSession.getImageEntityDao().insertInTx(imageEntities);
    }
    public List<ImageEntity> queryAllImg(){
        return daoSession.getImageEntityDao().loadAll();
    }
    public List<ImageEntity> queryByIdImg(int id){
        QueryBuilder<ImageEntity> db = daoSession.getImageEntityDao().queryBuilder();
        db.where(ImageEntityDao.Properties.Id.eq("id"));
        return db.list();
    }
    public void updataImageEntity(ImageEntity imageEntity){
        daoSession.getImageEntityDao().update(imageEntity);
    }
    public void deletaAllImageList(){
        daoSession.getImageEntityDao().deleteAll();
    }

    /**
     * 网友投稿的各种方法
     * **/
    public void saveSpecialList(List<SpecialEntity> specialEntities){
        daoSession.getSpecialEntityDao().insertInTx(specialEntities);
    }
    public List<SpecialEntity> queryAllSpecial(){
        return daoSession.getSpecialEntityDao().loadAll();
    }
    public List<SpecialEntity> queryByIdSpecial(int id){
        QueryBuilder<SpecialEntity> db = daoSession.getSpecialEntityDao().queryBuilder();
        db.where(SpecialEntityDao.Properties.Id.eq(id));
        return db.list();
    }
    public void updataSpecialEntity (SpecialEntity specialEntity){
        daoSession.getSpecialEntityDao().update(specialEntity);
    }
    /**
     * 收藏段子的数据库操作各种方法
     * **/
    //添加集合到数据库
    public void saveCollectList(List<CollectEntity> collectEntities){
        daoSession.getCollectEntityDao().insertInTx(collectEntities);
    }
    //添加一个对象到数据库
    public void saveCollectList(CollectEntity collectEntity){
        daoSession.getCollectEntityDao().insertOrReplace(collectEntity);
    }
    public void deleteAllCollect(){
        daoSession.getCollectEntityDao().deleteAll();
    }
    public List<CollectEntity> queryByIdCollect(String wid){
        QueryBuilder<CollectEntity> db = daoSession.getCollectEntityDao().queryBuilder();
        db.where(CollectEntityDao.Properties.Wid.eq("wid"));
        return db.list();
    }
    public void updataCollect(CollectEntity collectEntity){
        daoSession.getCollectEntityDao().update(collectEntity);
    }
    //按id删除
    public void deleteByIdCollect(String wid){
        daoSession.getCollectEntityDao().deleteByKey(wid);
    }
    public List<CollectEntity> queryAllCollect(){
        return daoSession.getCollectEntityDao().loadAll();
    }
    /**
     * 收藏图片的数据库操作各种方法
     * **/
    //添加对象到数据库
    public void saveCollectImageList(CollectImageEntity collectImageEntity){
        daoSession.getCollectImageEntityDao().insertOrReplace(collectImageEntity);
    }
    //按主键删除的方法
    public void deleteByIdCollectImage(long id){
        daoSession.getCollectImageEntityDao().deleteByKey(id);
    }
    //查询数据库全部方法
    public List<CollectImageEntity> queryAllImageCollect(){
        return daoSession.getCollectImageEntityDao().loadAll();
    }
    /**
     * 登录注册 用户名密码数据库
     * **/
    public void saveLoginList(List<LoginEntity> loginEntity){
        daoSession.getLoginEntityDao().insertInTx(loginEntity);
    }
    public void saveLoginList(LoginEntity loginEntity){
        daoSession.getLoginEntityDao().insertOrReplace(loginEntity);
    }
    public void deleteAllLogin(){
        daoSession.getLoginEntityDao().deleteAll();
    }
    public void deleteByIdLogin(String name){
        daoSession.getLoginEntityDao().deleteByKey(name);
    }
    public List<LoginEntity> queryAllLogin(){
        return daoSession.getLoginEntityDao().loadAll();
    }
    public boolean isLoginSave(String phone){//查询数据库手机号是否存在
        QueryBuilder<LoginEntity> qb = daoSession.getLoginEntityDao().queryBuilder();
        qb.where(LoginEntityDao.Properties.Phone.eq(phone));
        qb.buildCount().count();
        return  qb.buildCount().count() > 0 ? true : false;
    }
    public boolean isLoginName(String name){//查询数据库用户名是否存在
        QueryBuilder<LoginEntity> qb = daoSession.getLoginEntityDao().queryBuilder();
        qb.where(LoginEntityDao.Properties.Name.eq(name));
        qb.buildCount().count();
        return qb.buildCount().count() > 0 ? true : false;
    }
    public List<LoginEntity> queryByIdLogin(String phone){

        return daoSession.getLoginEntityDao().queryBuilder().where(LoginEntityDao.Properties.Phone.eq(phone)).list();
    }
    /**
     * 当前的登录账号存储数据库
     * (只有一个账号  方便在软件中设置信息)
     * 如果退出 需要删除当前数据库中的数据
     * **/
    //保存一条数据到数据库
    public void saveLoginOneList(LoginOneEntity loginOneEntity){
        daoSession.getLoginOneEntityDao().insertOrReplace(loginOneEntity);
    }
    //删除数据库数据
    public void deleteAllLoginOne(){
        daoSession.getLoginOneEntityDao().deleteAll();
    }
    //查询数据库所有数据
    public List<LoginOneEntity> queryLoginOne(){
        return daoSession.getLoginOneEntityDao().loadAll();
    }
    /**
     * 登录跳转选择页数据库操作方法
     * **/
    public List<IsChangeIntent> queryChange(){
        return daoSession.getIsChangeIntentDao().loadAll();
    }
    public void saveChange(IsChangeIntent isChangeIntent){
        daoSession.getIsChangeIntentDao().insertOrReplace(isChangeIntent);
    }





}
